from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
class MyDeepModel:
# learning rate seems to be a sensitive parameter
def __init__(self, learning_rate=0.02):
self._random_state = np.random.RandomState(0)
self._history = []
self.learning_rate = learning_rate
self.layers = [
# This is the layer corresponding to something like
# self._model.add(keras.layers.Dense(10, input_dim=2, activatoin="sigmoid"))
# in our DeepModel
Layer(2, 10, self._random_state),
# This is the output layer corresponding to
# self._model.add(keras.layers.Dense(units=1, activation="sigmoid"))
# in our DeepModel. Note that now we pass the object sigmoid as parameter, not the string.
Layer(10, 1, self._random_state)
]
def predict(self, X):
""" Takes input data of shape (n_items, n_features) and returns an array of shape (n_items,)
containing the labels predicted for each input x
"""
y_pred = []
# Here we register the predictions of the model for each input
# and store the results in a list
for x in X:
y_pred.append(self.forward(x)[-1])
y_pred = np.round(np.array(y_pred))
return y_pred
def fit(self, X, y, epochs=11, validation_split=0.2):
""" Train the model during a given number of epochs and plot the decision boundaries after each epoch.
This method performs one step of the backpropagation algorithm for each data example
by calling the forward, backward and update methods.
"""
self._history = {"train": [], "test": []}
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=validation_split,
random_state=self._random_state)
# One epoch corresponds to the training steps needed to train the model on the whole dataset once
for i in range(epochs):
for xt, yt in zip(X_train, y_train):
# The forward step predicts the class of the input
try:
outputs = self.forward(xt)
# The backward step backpropagate the error
gradients = self.backward(outputs, yt)
# Now, we update the weights
self.update(xt, outputs, gradients)
except NotImplementedError as e:
print(e)
return
y_pred = self.predict(X_train)
acc_train = accuracy_score(y_train, y_pred)
self._history["train"].append(acc_train)
y_pred = self.predict(X_test)
acc_test = accuracy_score(y_test, y_pred)
self._history["test"].append(acc_test)
print("Accuracy at epoch {}:\ntrain: {}\ntest: {}".format(i, acc_train, acc_test))
plot_decision_boundaries(X, y, self, step=i)
return self._history
def forward(self, x):
""" Forward pass of the backpropagation
Takes the one data example as input and returns the output values of each layer
"""
outputs = []
# TODO: Comment the line below and implement me!
raise NotImplementedError("Implement the forward function before testing.")
return outputs
def backward(self, outputs, y_true):
""" Backward pass of the backpropagation algorithm
Takes the output of the layer obtained in forward pass, compute and backpropagate the error,
and returns the obtained gradients
"""
gradients = []
# TODO: Comment the line below and implement me!
raise NotImplementedError("Implement the backward function before testing.")
return gradients
def update(self, x, outputs, gradients):
""" Update the weights after the backward pass of the backpropagation algorithm
Takes the gradient obtained during the backpropagation and update the weights of each layer
"""
# TODO: Comment the line below and implement me!
raise NotImplementedError("Implement the update function before testing.")
return None
